struct Candidate {
    uint id;
    string name;
    uint voteCount;
}

import "@openzeppelin/contracts/access/Ownable.sol";
contract Vote is Ownable {
    // 自动生成 owner 与 onlyOwner 修饰符
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/access/Ownable.sol";

/// @title 去中心化投票合约
/// @author 教程作者
/// @notice 支持管理员注册候选人、授权选民，并确保每人只能投一票
/// @dev 基于 OpenZeppelin Ownable 做访问控制
contract Vote is Ownable {

    /// @notice 候选人数据结构
    struct Candidate {
        uint id;
        string name;
        uint voteCount;
    }

    /// @notice 选举名称
    string public electionName;

    /// @notice 候选人总数，自动递增作为 ID 分配器
    uint public candidatesCount;

    /// @notice 候选人索引映射，id => Candidate
    mapping(uint => Candidate) public candidates;

    /// @notice 记录某地址是否已投票
    mapping(address => bool) public voted;

    /// @notice 授权选民白名单
    mapping(address => bool) public authorizedVoters;

    /// @notice 投票事件，用于前端实时监听
    /// @param voter 投票者地址
    /// @param candidateId 所投候选人 ID
    event Voted(address indexed voter, uint indexed candidateId);

    /// @notice 注册候选人事件
    /// @param candidateId 候选人 ID
    /// @param name 候选人名称
    event CandidateAdded(uint indexed candidateId, string name);

    /// @notice 选民授权事件
    /// @param voter 被授权地址
    event VoterAuthorized(address indexed voter);

    /// @param _electionName 选举主题名称
    constructor(string memory _electionName) Ownable(msg.sender) {
        electionName = _electionName;
    }

    /// @notice 管理员注册新候选人
    /// @param _name 候选人名称
    function addCandidate(string memory _name) public onlyOwner {
        candidatesCount++;
        candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
        emit CandidateAdded(candidatesCount, _name);
    }

    /// @notice 管理员将地址加入授权选民白名单
    /// @param _voter 待授权的以太坊地址
    function authorizeVoter(address _voter) public onlyOwner {
        authorizedVoters[_voter] = true;
        emit VoterAuthorized(_voter);
    }

    /// @notice 授权选民为指定候选人投票，每人只能投一次
    /// @param _candidateId 候选人 ID（1-based）
    function vote(uint _candidateId) public {
        // Step 1: 身份校验
        require(authorizedVoters[msg.sender], "Vote: caller is not an authorized voter");

        // Step 2: 防重复投票
        require(!voted[msg.sender], "Vote: already voted");

        // Step 3: 候选人存在性校验
        require(_candidateId > 0 && _candidateId <= candidatesCount, "Vote: invalid candidate ID");

        // Step 4: 先更新状态（Checks-Effects）
        voted[msg.sender] = true;

        // Step 5: 计票增加
        candidates[_candidateId].voteCount++;

        // Step 6: 触发事件（Interactions 的最后一步）
        emit Voted(msg.sender, _candidateId);
    }

    /// @notice 按 ID 查询候选人信息
    /// @param _id 候选人 ID
    /// @return 候选人结构体
    function getCandidate(uint _id) public view returns (Candidate memory) {
        require(_id > 0 && _id <= candidatesCount, "Vote: invalid candidate ID");
        return candidates[_id];
    }
}

mkdir voting-dapp && cd voting-dapp
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npx hardhat init   # 选择「Create a TypeScript project」或 JavaScript 项目
npm install @openzeppelin/contracts

voting-dapp/
├── contracts/
│   └── Vote.sol          # 将 17.2.5 的合约代码放入此处
├── scripts/
│   └── deploy.js         # 部署脚本
├── test/
│   └── Vote.test.js      # 单元测试（后续章节展开）
├── hardhat.config.js     # 编译器与网络配置
├── package.json
└── node_modules/

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    version: "0.8.19",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200,
      },
    },
  },
  // 默认网络为内置的 Hardhat Network，无需额外配置即可测试
  // 后续部署到 Sepolia 等测试网时，可在此添加 network 配置
};

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  // 获取部署者钱包地址
  const [deployer, voter1, voter2] = await hre.ethers.getSigners();
  console.log("部署者地址:", deployer.address);

  // 1. 编译并获取合约工厂
  const VoteFactory = await hre.ethers.getContractFactory("Vote");

  // 2. 部署合约，传入构造函数参数
  const voteContract = await VoteFactory.deploy("2024 社区治理选举");

  // 3. 等待部署上链
  await voteContract.waitForDeployment();
  console.log("投票合约已部署至:", await voteContract.getAddress());

  // 4. 管理员操作：注册候选人
  await (await voteContract.addCandidate("Alice - 建设更多公共节点")).wait();
  await (await voteContract.addCandidate("Bob - 优化 Gas 费分配")).wait();
  await (await voteContract.addCandidate("Charlie - 引入 DAO 治理")).wait();
  console.log("已注册 3 名候选人");

  // 5. 管理员操作：授权测试选民
  await (await voteContract.authorizeVoter(voter1.address)).wait();
  await (await voteContract.authorizeVoter(voter2.address)).wait();
  console.log("已授权测试选民:", voter1.address, voter2.address);

  // 6. 初始状态查询
  const c1 = await voteContract.getCandidate(1);
  console.log(`候选人 #1: ${c1.name}, 当前票数:${c1.voteCount}`);
}

// 优雅处理异步异常
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/deploy.js --network hardhat

npx hardhat node

npx hardhat console --network localhost

// 加载已部署的合约（替换为 deploy.js 输出的实际地址）
const Vote = await ethers.getContractFactory("Vote");
const vote = await Vote.attach("0x5FbDB2315678afecb367f032d93F642f64180aa3");

// 获取可用签名者
const [owner, voter1, voter2, stranger] = await ethers.getSigners();

// 查询候选人信息
await vote.getCandidate(1);
// 返回: [ 1n, 'Alice - 建设更多公共节点', 0n ]

// 以 voter1 身份投票
await vote.connect(voter1).vote(1);
// 交易确认后，voter1 成功投票给候选人 1

// 再次查询票数
await vote.getCandidate(1);
// 返回: [ 1n, 'Alice - 建设更多公共节点', 1n ]

// 尝试重复投票（应被回滚）
await vote.connect(voter1).vote(2);
// 抛出: Error: VM Exception while processing transaction: reverted with reason string 'Vote: already voted'

// 以未授权地址投票（应被回滚）
await vote.connect(stranger).vote(1);
// 抛出: Error: VM Exception while processing transaction: reverted with reason string 'Vote: caller is not an authorized voter'

// 以 voter2 投票给不同候选人
await vote.connect(voter2).vote(3);
await vote.getCandidate(3);
// 返回: [ 3n, 'Charlie - 引入 DAO 治理', 1n ]

voting-dapp/
├── contracts/
│   └── Vote.sol              # 投票主合约（Solidity 0.8.19）
├── scripts/
│   └── deploy.js             # 部署与初始化脚本
├── test/
│   └── Vote.test.js          # 单元测试（将在后续章节展开）
├── node_modules/             # 依赖包（Hardhat、OpenZeppelin 等）
├── hardhat.config.js         # 编译器与网络配置
├── package.json
└── package-lock.json

// test/Voting.test.js
const { expect } = require("chai");

describe("Voting 合约测试", function () {
  let voting;
  let owner, voterA, voterB, attacker;

  // 每用例重置，避免状态污染
  beforeEach(async () => {
    [owner, voterA, voterB, attacker] = await ethers.getSigners();
    const VotingFactory = await ethers.getContractFactory("Voting");
    voting = await VotingFactory.deploy(["Alice", "Bob"]);
    await voting.setVoterStatus(voterA.address, true);
  });

  it("应创建候选人", async () => {
    const candidates = await voting.getCandidates();
    expect(candidates).to.deep.equal(["Alice", "Bob"]);
  });

  it("授权选民可投票并能正确增量", async () => {
    await voting.connect(voterA).vote(0);
    const count = await voting.votes(0);
    expect(count).to.equal(1);
  });

  it("非法选民尝试投票应回滚", async () => {
    await expect(
      voting.connect(attacker).vote(0)
    ).to.be.revertedWith("Not authorized voter");
  });

  it("重复投票应回滚", async () => {
    await voting.connect(voterA).vote(0);
    await expect(
      voting.connect(voterA).vote(0)
    ).to.be.revertedWith("Already voted");
  });
});

// src/hooks/useContract.js
import { useMemo } from "react";
import { Contract, JsonRpcProvider, BrowserProvider } from "ethers";
import abi from "../artifacts/contracts/Voting.sol/Voting.json";

const CONTRACT_ADDRESS = "0x..."; // 部署后替换

export function useContract(signer = null) {
  return useMemo(() => {
    if (!signer) return null;
    // signer 模式下以写入
    const contract = new Contract(CONTRACT_ADDRESS, abi.abi, signer);
    return contract;
  }, [signer]);
}

export function useReadContract() {
  return useMemo(() => {
    const provider = new JsonRpcProvider("https://rpc.sepolia.org");
    return new Contract(CONTRACT_ADDRESS, abi.abi, provider);
  }, []);
}

// src/components/CandidateList.jsx
import { useEffect, useState } from "react";
import { useReadContract } from "../hooks/useContract";

export default function CandidateList() {
  const [candidates, setCandidates] = useState([]);
  const contract = useReadContract();

  useEffect(() => {
    if (!contract) return;
    const fetch = async () => {
      const list = await contract.getCandidates();
      setCandidates(list);
    };
    fetch();
  }, [contract]);

  return (
    <ul className="candidate-list">
      {candidates.map((name, idx) => (
        <li key={idx}>
          <span className="id">{idx}</span> {name}
        </li>
      ))}
    </ul>
  );
}

// src/components/VoteButton.jsx
import { useState } from "react";

export default function VoteButton({ contract }) {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  const [tx, setTx] = useState(null);

  const vote = async (candidateId) => {
    if (!contract) return;
    setError(null);
    setTx(null);
    setLoading(true);
    try {
      const txReq = await contract.vote(candidateId);
      setTx(`广播中... Hash: ${txReq.hash.slice(0, 12)}...`);
      const receipt = await txReq.wait();
      setTx(`确认成功！区块号: ${receipt.blockNumber}`);
    } catch (err) {
      setError(err.code === 4001 ? "用户取消了交易" : err.message);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div>
      <button onClick={() => vote(0)} disabled={!contract || loading}>
        {loading ? "投票中..." : "投票给 Alice"}
      </button>
      {tx && <p className="success">✅ {tx}</p>}
      {error && <p className="error">❌ {error}</p>}
    </div>
  );
}

// src/components/WalletConnect.jsx
import { useState } from "react";
import { BrowserProvider } from "ethers";
import { useContract } from "../hooks/useContract";

export default function WalletConnect({ onConnect }) {
  const [status, setStatus] = useState("未连接");
  const [address, setAddress] = useState(null);

  const connectWallet = async () => {
    if (typeof window.ethereum === "undefined") {
      setStatus("未检测到兼容钱包，请安装 MetaMask");
      return;
    }
    try {
      const provider = new BrowserProvider(window.ethereum);
      const accounts = await provider.send("eth_requestAccounts", []);
      const signer = await provider.getSigner();
      setAddress(accounts[0]);
      setStatus("已连接");
      onConnect(signer);
    } catch (err) {
      if (err.code === 4001) {
        setStatus("用户拒绝了账户授权");
      } else {
        setStatus("连接失败: " + err.message);
      }
    }
  };

  return (
    <div className="wallet-connect">
      <p>状态: <b>{status}</b></p>
      {address && <p>地址: {address.slice(0, 10)}...{address.slice(-6)}</p>}
      <button onClick={connectWallet}>连接钱包</button>
    </div>
  );
}

// 网络配置映射
const SUPPORTED_CHAIN = 0xaa36a7; // Sepolia 测试网
const SEPOLIA_RPC = "https://rpc.sepolia.org";

async function checkAndSwitchNetwork() {
  const chainId = await window.ethereum.request({ method: "eth_chainId" });
  if (Number(chainId) !== SUPPORTED_CHAIN) {
    try {
      await window.ethereum.request({
        method: "wallet_switchEthereumChain",
        params: [{ chainId: `0x${SUPPORTED_CHAIN.toString(16)}` }],
      });
    } catch (err) {
      if (err.code === 4902) {
        // 用户未添加目标网络，请求添加
        await window.ethereum.request({
          method: "wallet_addEthereumChain",
          params: [{
            chainId: `0x${SUPPORTED_CHAIN.toString(16)}`,
            chainName: "Sepolia 测试网",
            rpcUrls: [SEPOLIA_RPC],
          }],
        });
      } else {
        throw err;
      }
    }
  }
}

// 带 Gas Limit 估算的投票交易发送
const sendVoteTransaction = async (contract, candidateId) => {
  const txReq = await contract.vote.populateTransaction(candidateId);
  const gasEstimate = await contract.runner.estimateGas(txReq);
  const gasLimit = (gasEstimate * 120n) / 100n; // 增加 20% 安全余量

  const tx = await contract.vote(candidateId, { gasLimit });
  return tx.wait();
};

// 投票前的链下身份验证（可选）
async function signAuthorization(signer, account, candidateId) {
  const message = `I authorize my address {account} to vote for candidate #{candidateId}`;
  const signature = await signer.signMessage(message);
  return { account, message, signature };
  // 后端验证：ethers.utils.verifyMessage(message, signature) === account
}

event Voted(address indexed voter, uint indexed candidateId, uint timestamp);

// hooks/useEventListener.js
import { useEffect, useRef } from 'react';
import { ethers } from 'ethers';

export function useEventListener(contract, eventName, callback) {
  const callbackRef = useRef(callback);
  callbackRef.current = callback; // 保证闭包中的callback始终最新

  useEffect(() => {
    if (!contract) return;

    const handler = (...args) => {
      const event = args[args.length - 1]; // 最后一个参数是Event对象
      callbackRef.current(args.slice(0, -1), event);
    };

    contract.on(eventName, handler);

    return () => {
      contract.off(eventName, handler); // 组件卸载时必须清理！
    };
  }, [contract, eventName]);
}

useEventListener(contract, 'Voted', (args, event) => {
  const [voter, candidateId, timestamp] = args;
  setVotes(prev => ({
    ...prev,
    [candidateId.toString()]: (prev[candidateId.toString()] || 0) + 1,
  }));
});

// 页面加载时拉取最新状态
useEffect(() => {
  if (!contract) return;
  const loadCandidates = async () => {
    const count = await contract.getCandidateCount();
    // ... 遍历并拉取每个候选人数据
  };
  loadCandidates();
  // 后续更新由事件驱动
}, [contract]);

import { BarChart, Bar, XAxis, YAxis, Tooltip } from 'recharts';

function ResultsChart({ candidates }) {
  const data = candidates.map(c => ({
    name: c.name,
    得票数: c.voteCount,
  }));

  return (
    <BarChart width={600} height={300} data={data}>
      <XAxis dataKey="name" />
      <YAxis />
      <Tooltip />
      <Bar dataKey="得票数" fill="#8884d8" />
    </BarChart>
  );
}

# .env — 禁止提交到Git！
PRIVATE_KEY=0x你的测试网私钥（不含0x前缀）
INFURA_API_KEY=你的Infura项目ID
ETHERSCAN_API_KEY=你的Etherscan API Key

import { HardhatUserConfig } from 'hardhat/config';
import '@nomicfoundation/hardhat-toolbox';
import * as dotenv from 'dotenv';

dotenv.config();

const config: HardhatUserConfig = {
  solidity: '0.8.20',
  networks: {
    sepolia: {
      url: `https://sepolia.infura.io/v3/${process.env.INFURA_API_KEY}`,
      accounts: [process.env.PRIVATE_KEY!],
      // EIP-1559: 交易类型2的参数
      maxFeePerGas: 100_000_000_000n,   // 100 gwei
      maxPriorityFeePerGas: 5_000_000_000n, // 5 gwei
    },
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
};

export default config;

// scripts/deploy.js
const hre = require('hardhat');

async function main() {
  const [deployer] = await hre.ethers.getSigners();
  console.log('部署账户:', deployer.address);

  const candidates = ['Alice', 'Bob', 'Charlie'];
  const Election = await hre.ethers.getContractFactory('Election');
  const election = await Election.deploy(candidates);

  await election.waitForDeployment();

  const addr = await election.getAddress();
  console.log('选举合约已部署至:', addr);
  console.log('候选人:', candidates.join(', '));

  // 输出验证命令
  console.log('\n运行验证命令:');
  console.log(`npx hardhat verify --network sepolia ${addr} "${candidates.join('","')}"`);
}

main().catch(console.error);

npx hardhat run scripts/deploy.js --network sepolia

npx hardhat verify --network sepolia <合约地址> "Alice" "Bob" "Charlie"

voting-dapp/
├── contracts/                    # Solidity源代码
│   ├── Election.sol              # 核心投票合约
│   └── VoterRegistry.sol         # 选民注册合约
├── test/
│   └── election.test.js          # 合约单元测试
├── scripts/
│   ├── deploy.js                 # 部署脚本
│   └── verify.js                 # 验证脚本
├── frontend/
│   ├── src/
│   │   ├── App.jsx               # 主应用入口
│   │   ├── components/
│   │   │   ├── WalletConnect.jsx  # 钱包连接
│   │   │   ├── ElectionInfo.jsx   # 选举信息展示
│   │   │   ├── CandidateList.jsx  # 候选人列表
│   │   │   ├── VoteButton.jsx     # 投票按钮
│   │   │   └── ResultsChart.jsx   # 结果图表
│   │   ├── hooks/
│   │   │   ├── useContract.js     # 合约交互Hook
│   │   │   └── useEventListener.js# 事件监听Hook
│   │   └── utils/
│   │       └── constants.js       # 合约地址/ABI常量
│   ├── package.json
│   └── vite.config.js
├── hardhat.config.ts
├── .env
└── README.md